/*
    * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    *
    * This code is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License version 2 only, as
    * published by the Free Software Foundation.  Oracle designates this
    * particular file as subject to the "Classpath" exception as provided
    * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  package com.sun.java.util.jar.pack;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Random;
  import java.util.Set;
  import java.util.zip.Deflater;
  import java.util.zip.DeflaterOutputStream;
  import static com.sun.java.util.jar.pack.Constants.*;
  /**
   * Heuristic chooser of basic encodings.
   * Runs "zip" to measure the apparent information content after coding.
   * @author John Rose
   */
  class CodingChooser {
      int verbose;
      int effort;
      boolean optUseHistogram = true;
      boolean optUsePopulationCoding = true;
      boolean optUseAdaptiveCoding = true;
      boolean disablePopCoding;
      boolean disableRunCoding;
      boolean topLevel = true;
  
      // Derived from effort; >1 (<1) means try more (less) experiments
      // when looking to beat a best score.
      double fuzz;
  
      Coding[] allCodingChoices;
      Choice[] choices;
      ByteArrayOutputStream context;
      CodingChooser popHelper;
      CodingChooser runHelper;
  
      Random stress;  // If not null, stress mode oracle.
  
      // Element in sorted set of coding choices:
      static
      class Choice {
          final Coding coding;
          final int index;       // index in choices
          final int[] distance;  // cache of distance
          Choice(Coding coding, int index, int[] distance) {
              this.coding   = coding;
              this.index    = index;
              this.distance = distance;
          }
          // These variables are reset and reused:
          int searchOrder; // order in which it is checked
          int minDistance; // min distance from already-checked choices
          int zipSize;     // size of encoding in sample, zipped output
          int byteSize;    // size of encoding in sample (debug only)
          int histSize;    // size of encoding, according to histogram
  
          void reset() {
              searchOrder = Integer.MAX_VALUE;
              minDistance = Integer.MAX_VALUE;
              zipSize = byteSize = histSize = -1;
          }
  
          boolean isExtra() {
              return index < 0;
          }
  
          public String toString() {
              return stringForDebug();
          }
  
         private String stringForDebug() {
             String s = "";
             if (searchOrder < Integer.MAX_VALUE)
                 s += " so: "+searchOrder;
             if (minDistance < Integer.MAX_VALUE)
                 s += " md: "+minDistance;
             if (zipSize > 0)
                 s += " zs: "+zipSize;
             if (byteSize > 0)
                 s += " bs: "+byteSize;
             if (histSize > 0)
                 s += " hs: "+histSize;
             return "Choice["+index+"] "+s+" "+coding;
         }
     }
 
     CodingChooser(int effort, Coding[] allCodingChoices) {
         PropMap p200 = Utils.currentPropMap();
         if (p200 != null) {
             this.verbose
                 = Math.max(p200.getInteger(Utils.DEBUG_VERBOSE),
                            p200.getInteger(Utils.COM_PREFIX+"verbose.coding"));
             this.optUseHistogram
                 = !p200.getBoolean(Utils.COM_PREFIX+"no.histogram");
             this.optUsePopulationCoding
                 = !p200.getBoolean(Utils.COM_PREFIX+"no.population.coding");
             this.optUseAdaptiveCoding
                 = !p200.getBoolean(Utils.COM_PREFIX+"no.adaptive.coding");
             int lstress
                 = p200.getInteger(Utils.COM_PREFIX+"stress.coding");
             if (lstress != 0)
                 this.stress = new Random(lstress);
         }
 
         this.effort = effort;
         // The following line "makes sense" but is too much
         // work for a simple heuristic.
         //if (effort > 5)  zipDef.setLevel(effort);
 
         this.allCodingChoices = allCodingChoices;
 
         // If effort = 9, look carefully at any solution
         // whose initial metrics are within 1% of the best
         // so far.  If effort = 1, look carefully only at
         // solutions whose initial metrics promise a 1% win.
         this.fuzz = 1 + (0.0025 * (effort-MID_EFFORT));
 
         int nc = 0;
         for (int i = 0; i < allCodingChoices.length; i++) {
             if (allCodingChoices[i] == null)  continue;
             nc++;
         }
         choices = new Choice[nc];
         nc = 0;
         for (int i = 0; i < allCodingChoices.length; i++) {
             if (allCodingChoices[i] == null)  continue;
             int[] distance = new int[choices.length];
             choices[nc++] = new Choice(allCodingChoices[i], i, distance);
         }
         for (int i = 0; i < choices.length; i++) {
             Coding ci = choices[i].coding;
             assert(ci.distanceFrom(ci) == 0);
             for (int j = 0; j < i; j++) {
                 Coding cj = choices[j].coding;
                 int dij = ci.distanceFrom(cj);
                 assert(dij > 0);
                 assert(dij == cj.distanceFrom(ci));
                 choices[i].distance[j] = dij;
                 choices[j].distance[i] = dij;
             }
         }
     }
 
     Choice makeExtraChoice(Coding coding) {
         int[] distance = new int[choices.length];
         for (int i = 0; i < distance.length; i++) {
             Coding ci = choices[i].coding;
             int dij = coding.distanceFrom(ci);
             assert(dij > 0);
             assert(dij == ci.distanceFrom(coding));
             distance[i] = dij;
         }
         Choice c = new Choice(coding, -1, distance);
         c.reset();
         return c;
     }
 
     ByteArrayOutputStream getContext() {
         if (context == null)
             context = new ByteArrayOutputStream(1 << 16);
         return context;
     }
 
     // These variables are reset and reused:
     private int[] values;
     private int start, end;  // slice of values
     private int[] deltas;
     private int min, max;
     private Histogram vHist;
     private Histogram dHist;
     private int searchOrder;
     private Choice regularChoice;
     private Choice bestChoice;
     private CodingMethod bestMethod;
     private int bestByteSize;
     private int bestZipSize;
     private int targetSize;   // fuzzed target byte size
 
     private void reset(int[] values, int start, int end) {
         this.values = values;
         this.start = start;
         this.end = end;
         this.deltas = null;
         this.min = Integer.MAX_VALUE;
         this.max = Integer.MIN_VALUE;
         this.vHist = null;
         this.dHist = null;
         this.searchOrder = 0;
         this.regularChoice = null;
         this.bestChoice = null;
         this.bestMethod = null;
         this.bestZipSize = Integer.MAX_VALUE;
         this.bestByteSize = Integer.MAX_VALUE;
         this.targetSize = Integer.MAX_VALUE;
     }
 
     public static final int MIN_EFFORT = 1;
     public static final int MID_EFFORT = 5;
     public static final int MAX_EFFORT = 9;
 
     public static final int POP_EFFORT = MID_EFFORT-1;
     public static final int RUN_EFFORT = MID_EFFORT-2;
 
     public static final int BYTE_SIZE = 0;
     public static final int ZIP_SIZE = 1;
 
     CodingMethod choose(int[] values, int start, int end, Coding regular, int[] sizes) {
         // Save the value array
         reset(values, start, end);
 
         if (effort <= MIN_EFFORT || start >= end) {
             if (sizes != null) {
                 int[] computed = computeSizePrivate(regular);
                 sizes[BYTE_SIZE] = computed[BYTE_SIZE];
                 sizes[ZIP_SIZE]  = computed[ZIP_SIZE];
             }
             return regular;
         }
 
         if (optUseHistogram) {
             getValueHistogram();
             getDeltaHistogram();
         }
 
         for (int i = start; i < end; i++) {
             int val = values[i];
             if (min > val)  min = val;
             if (max < val)  max = val;
         }
 
         // Find all the preset choices that might be worth looking at:
         int numChoices = markUsableChoices(regular);
 
         if (stress != null) {
             // Make a random choice.
             int rand = stress.nextInt(numChoices*2 + 4);
             CodingMethod coding = null;
             for (int i = 0; i < choices.length; i++) {
                 Choice c = choices[i];
                 if (c.searchOrder >= 0 && rand-- == 0) {
                     coding = c.coding;
                     break;
                 }
             }
             if (coding == null) {
                 if ((rand & 7) != 0) {
                     coding = regular;
                 } else {
                     // Pick a totally random coding 6% of the time.
                     coding = stressCoding(min, max);
                 }
             }
             if (!disablePopCoding
                 && optUsePopulationCoding
                 && effort >= POP_EFFORT) {
                 coding = stressPopCoding(coding);
             }
             if (!disableRunCoding
                 && optUseAdaptiveCoding
                 && effort >= RUN_EFFORT) {
                 coding = stressAdaptiveCoding(coding);
             }
             return coding;
         }
 
         double searchScale = 1.0;
         for (int x = effort; x < MAX_EFFORT; x++) {
             searchScale /= 1.414;  // every 2 effort points doubles work
         }
         int searchOrderLimit = (int)Math.ceil( numChoices * searchScale );
 
         // Start by evaluating the "regular" choice.
         bestChoice = regularChoice;
         evaluate(regularChoice);
         int maxd = updateDistances(regularChoice);
 
         // save these first-cut numbers for later
         int zipSize1 = bestZipSize;
         int byteSize1 = bestByteSize;
 
         if (regularChoice.coding == regular && topLevel) {
             // Give credit for being the default; no band header is needed.
             // Rather than increasing every other size value by the band
             // header amount, we decrement this one metric, to give it an edge.
             // Decreasing zipSize by a byte length is conservatively correct,
             // especially considering that the escape byte is not likely to
             // zip well with other bytes in the band.
             int X = BandStructure.encodeEscapeValue(_meta_canon_max, regular);
             if (regular.canRepresentSigned(X)) {
                 int Xlen = regular.getLength(X);  // band coding header
                 //regularChoice.histSize -= Xlen; // keep exact byteSize
                 //regularChoice.byteSize -= Xlen; // keep exact byteSize
                 regularChoice.zipSize -= Xlen;
                 bestByteSize = regularChoice.byteSize;
                 bestZipSize = regularChoice.zipSize;
             }
         }
 
         int dscale = 1;
         // Continually select a new choice to evaluate.
         while (searchOrder < searchOrderLimit) {
             Choice nextChoice;
             if (dscale > maxd)  dscale = 1;  // cycle dscale values!
             int dhi = maxd / dscale;
             int dlo = maxd / (dscale *= 2) + 1;
             nextChoice = findChoiceNear(bestChoice, dhi, dlo);
             if (nextChoice == null)  continue;
             assert(nextChoice.coding.canRepresent(min, max));
             evaluate(nextChoice);
             int nextMaxd = updateDistances(nextChoice);
             if (nextChoice == bestChoice) {
                 maxd = nextMaxd;
                 if (verbose > 5)  Utils.log.info("maxd = "+maxd);
             }
         }
 
         // Record best "plain coding" choice.
         Coding plainBest = bestChoice.coding;
         assert(plainBest == bestMethod);
 
         if (verbose > 2) {
             Utils.log.info("chooser: plain result="+bestChoice+" after "+bestChoice.searchOrder+" rounds, "+(regularChoice.zipSize-bestZipSize)+" fewer bytes than regular "+regular);
         }
         bestChoice = null;
 
         if (!disablePopCoding
             && optUsePopulationCoding
             && effort >= POP_EFFORT
             && bestMethod instanceof Coding) {
             tryPopulationCoding(plainBest);
         }
 
         if (!disableRunCoding
             && optUseAdaptiveCoding
             && effort >= RUN_EFFORT
             && bestMethod instanceof Coding) {
             tryAdaptiveCoding(plainBest);
         }
 
         // Pass back the requested information:
         if (sizes != null) {
             sizes[BYTE_SIZE] = bestByteSize;
             sizes[ZIP_SIZE]  = bestZipSize;
         }
         if (verbose > 1) {
             Utils.log.info("chooser: result="+bestMethod+" "+
                              (zipSize1-bestZipSize)+
                              " fewer bytes than regular "+regular+
                              "; win="+pct(zipSize1-bestZipSize, zipSize1));
         }
         CodingMethod lbestMethod = this.bestMethod;
         reset(null, 0, 0);  // for GC
         return lbestMethod;
     }
     CodingMethod choose(int[] values, int start, int end, Coding regular) {
         return choose(values, start, end, regular, null);
     }
     CodingMethod choose(int[] values, Coding regular, int[] sizes) {
         return choose(values, 0, values.length, regular, sizes);
     }
     CodingMethod choose(int[] values, Coding regular) {
         return choose(values, 0, values.length, regular, null);
     }
 
     private int markUsableChoices(Coding regular) {
         int numChoices = 0;
         for (int i = 0; i < choices.length; i++) {
             Choice c = choices[i];
             c.reset();
             if (!c.coding.canRepresent(min, max)) {
                 // Mark as already visited:
                 c.searchOrder = -1;
                 if (verbose > 1 && c.coding == regular) {
                     Utils.log.info("regular coding cannot represent ["+min+".."+max+"]: "+regular);
                 }
                 continue;
             }
             if (c.coding == regular)
                 regularChoice = c;
             numChoices++;
         }
         if (regularChoice == null && regular.canRepresent(min, max)) {
             regularChoice = makeExtraChoice(regular);
             if (verbose > 1) {
                 Utils.log.info("*** regular choice is extra: "+regularChoice.coding);
             }
         }
         if (regularChoice == null) {
             for (int i = 0; i < choices.length; i++) {
                 Choice c = choices[i];
                 if (c.searchOrder != -1) {
                     regularChoice = c;  // arbitrary pick
                     break;
                 }
             }
             if (verbose > 1) {
                 Utils.log.info("*** regular choice does not apply "+regular);
                 Utils.log.info("    using instead "+regularChoice.coding);
             }
         }
         if (verbose > 2) {
             Utils.log.info("chooser: #choices="+numChoices+" ["+min+".."+max+"]");
             if (verbose > 4) {
                 for (int i = 0; i < choices.length; i++) {
                     Choice c = choices[i];
                     if (c.searchOrder >= 0)
                         Utils.log.info("  "+c);
                 }
             }
         }
         return numChoices;
     }
 
     // Find an arbitrary choice at least dlo away from a previously
     // evaluated choices, and at most dhi.  Try also to regulate its
     // min distance to all previously evaluated choices, in this range.
     private Choice findChoiceNear(Choice near, int dhi, int dlo) {
         if (verbose > 5)
             Utils.log.info("findChoice "+dhi+".."+dlo+" near: "+near);
         int[] distance = near.distance;
         Choice found = null;
         for (int i = 0; i < choices.length; i++) {
             Choice c = choices[i];
             if (c.searchOrder < searchOrder)
                 continue;  // already searched
             // Distance from "near" guy must be in bounds:
             if (distance[i] >= dlo && distance[i] <= dhi) {
                 // Try also to keep min-distance from other guys in bounds:
                 if (c.minDistance >= dlo && c.minDistance <= dhi) {
                     if (verbose > 5)
                         Utils.log.info("findChoice => good "+c);
                     return c;
                 }
                 found = c;
             }
         }
         if (verbose > 5)
             Utils.log.info("findChoice => found "+found);
         return found;
     }
 
     private void evaluate(Choice c) {
         assert(c.searchOrder == Integer.MAX_VALUE);
         c.searchOrder = searchOrder++;
         boolean mustComputeSize;
         if (c == bestChoice || c.isExtra()) {
             mustComputeSize = true;
         } else if (optUseHistogram) {
             Histogram hist = getHistogram(c.coding.isDelta());
             c.histSize = (int)Math.ceil(hist.getBitLength(c.coding) / 8);
             c.byteSize = c.histSize;
             mustComputeSize = (c.byteSize <= targetSize);
         } else {
             mustComputeSize = true;
         }
         if (mustComputeSize) {
             int[] sizes = computeSizePrivate(c.coding);
             c.byteSize = sizes[BYTE_SIZE];
             c.zipSize  = sizes[ZIP_SIZE];
             if (noteSizes(c.coding, c.byteSize, c.zipSize))
                 bestChoice = c;
         }
         if (c.histSize >= 0) {
             assert(c.byteSize == c.histSize);  // models should agree
         }
         if (verbose > 4) {
             Utils.log.info("evaluated "+c);
         }
     }
 
     private boolean noteSizes(CodingMethod c, int byteSize, int zipSize) {
         assert(zipSize > 0 && byteSize > 0);
         boolean better = (zipSize < bestZipSize);
         if (verbose > 3)
             Utils.log.info("computed size "+c+" "+byteSize+"/zs="+zipSize+
                              ((better && bestMethod != null)?
                               (" better by "+
                                pct(bestZipSize - zipSize, zipSize)): ""));
         if (better) {
             bestMethod = c;
             bestZipSize = zipSize;
             bestByteSize = byteSize;
             targetSize = (int)(byteSize * fuzz);
             return true;
         } else {
             return false;
         }
     }
 
 
     private int updateDistances(Choice c) {
         // update all minDistance values in still unevaluated choices
         int[] distance = c.distance;
         int maxd = 0;  // how far is c from everybody else?
         for (int i = 0; i < choices.length; i++) {
             Choice c2 = choices[i];
             if (c2.searchOrder < searchOrder)
                 continue;
             int d = distance[i];
             if (verbose > 5)
                 Utils.log.info("evaluate dist "+d+" to "+c2);
             int mind = c2.minDistance;
             if (mind > d)
                 c2.minDistance = mind = d;
             if (maxd < d)
                 maxd = d;
         }
         // Now maxd has the distance of the farthest outlier
         // from all evaluated choices.
         if (verbose > 5)
             Utils.log.info("evaluate maxd => "+maxd);
         return maxd;
     }
 
     // Compute the coded size of a sequence of values.
     // The first int is the size in uncompressed bytes.
     // The second is an estimate of the compressed size of these bytes.
     public void computeSize(CodingMethod c, int[] values, int start, int end, int[] sizes) {
         if (end <= start) {
             sizes[BYTE_SIZE] = sizes[ZIP_SIZE] = 0;
             return;
         }
         try {
             resetData();
             c.writeArrayTo(byteSizer, values, start, end);
             sizes[BYTE_SIZE] = getByteSize();
             sizes[ZIP_SIZE] = getZipSize();
         } catch (IOException ee) {
             throw new RuntimeException(ee); // cannot happen
         }
     }
     public void computeSize(CodingMethod c, int[] values, int[] sizes) {
         computeSize(c, values, 0, values.length, sizes);
     }
     public int[] computeSize(CodingMethod c, int[] values, int start, int end) {
         int[] sizes = { 0, 0 };
         computeSize(c, values, start, end, sizes);
         return sizes;
     }
     public int[] computeSize(CodingMethod c, int[] values) {
         return computeSize(c, values, 0, values.length);
     }
     // This version uses the implicit local arguments
     private int[] computeSizePrivate(CodingMethod c) {
         int[] sizes = { 0, 0 };
         computeSize(c, values, start, end, sizes);
         return sizes;
     }
     public int computeByteSize(CodingMethod cm, int[] values, int start, int end) {
         int len = end-start;
         if (len < 0) {
             return 0;
         }
         if (cm instanceof Coding) {
             Coding c = (Coding) cm;
             int size = c.getLength(values, start, end);
             int size2;
             assert(size == (size2=countBytesToSizer(cm, values, start, end)))
                 : (cm+" : "+size+" != "+size2);
             return size;
         }
         return countBytesToSizer(cm, values, start, end);
     }
     private int countBytesToSizer(CodingMethod cm, int[] values, int start, int end) {
         try {
             byteOnlySizer.reset();
             cm.writeArrayTo(byteOnlySizer, values, start, end);
             return byteOnlySizer.getSize();
         } catch (IOException ee) {
             throw new RuntimeException(ee); // cannot happen
         }
     }
 
     int[] getDeltas(int min, int max) {
         if ((min|max) != 0)
             return Coding.makeDeltas(values, start, end, min, max);
         if (deltas == null) {
             deltas = Coding.makeDeltas(values, start, end, 0, 0);
         }
         return deltas;
     }
     Histogram getValueHistogram() {
         if (vHist == null) {
             vHist = new Histogram(values, start, end);
             if (verbose > 3) {
                 vHist.print("vHist", System.out);
             } else if (verbose > 1) {
                 vHist.print("vHist", null, System.out);
             }
         }
         return vHist;
     }
     Histogram getDeltaHistogram() {
         if (dHist == null) {
             dHist = new Histogram(getDeltas(0, 0));
             if (verbose > 3) {
                 dHist.print("dHist", System.out);
             } else if (verbose > 1) {
                 dHist.print("dHist", null, System.out);
             }
         }
         return dHist;
     }
     Histogram getHistogram(boolean isDelta) {
         return isDelta ? getDeltaHistogram(): getValueHistogram();
     }
 
     private void tryPopulationCoding(Coding plainCoding) {
         // assert(plainCoding.canRepresent(min, max));
         Histogram hist = getValueHistogram();
         // Start with "reasonable" default codings.
         final int approxL = 64;
         Coding favoredCoding = plainCoding.getValueCoding();
         Coding tokenCoding = BandStructure.UNSIGNED5.setL(approxL);
         Coding unfavoredCoding = plainCoding.getValueCoding();
         // There's going to be a band header.  Estimate conservatively large.
         final int BAND_HEADER = 4;
         // Keep a running model of the predicted sizes of the F/T/U sequences.
         int currentFSize;
         int currentTSize;
         int currentUSize;
         // Start by assuming a degenerate favored-value length of 0,
         // which looks like a bunch of zero tokens followed by the
         // original sequence.
         // The {F} list ends with a repeated F value; find worst case:
         currentFSize =
             BAND_HEADER + Math.max(favoredCoding.getLength(min),
                                    favoredCoding.getLength(max));
         // The {T} list starts out a bunch of zeros, each of length 1.
         final int ZERO_LEN = tokenCoding.getLength(0);
         currentTSize = ZERO_LEN * (end-start);
         // The {U} list starts out a copy of the plainCoding:
         currentUSize = (int) Math.ceil(hist.getBitLength(unfavoredCoding) / 8);
 
         int bestPopSize = (currentFSize + currentTSize + currentUSize);
         int bestPopFVC  = 0;
 
         // Record all the values, in decreasing order of favor.
         int[] allFavoredValues = new int[1+hist.getTotalLength()];
         //int[] allPopSizes    = new int[1+hist.getTotalLength()];
 
         // What sizes are "interesting"?
         int targetLowFVC = -1;
         int targetHighFVC = -1;
 
         // For each length, adjust the currentXSize model, and look for a win.
         int[][] matrix = hist.getMatrix();
         int mrow = -1;
         int mcol = 1;
         int mrowFreq = 0;
         for (int fvcount = 1; fvcount <= hist.getTotalLength(); fvcount++) {
             // The {F} list gets an additional member.
             // Take it from the end of the current matrix row.
             // (It's the end, so that we get larger favored values first.)
             if (mcol == 1) {
                 mrow += 1;
                 mrowFreq = matrix[mrow][0];
                 mcol = matrix[mrow].length;
             }
             int thisValue = matrix[mrow][--mcol];
             allFavoredValues[fvcount] = thisValue;
             int thisVLen = favoredCoding.getLength(thisValue);
             currentFSize += thisVLen;
             // The token list replaces occurrences of zero with a new token:
             int thisVCount = mrowFreq;
             int thisToken = fvcount;
             currentTSize += (tokenCoding.getLength(thisToken)
                              - ZERO_LEN) * thisVCount;
             // The unfavored list loses occurrences of the newly favored value.
             // (This is the whole point of the exercise!)
             currentUSize -= thisVLen * thisVCount;
             int currentSize = (currentFSize + currentTSize + currentUSize);
             //allPopSizes[fvcount] = currentSize;
             if (bestPopSize > currentSize) {
                 if (currentSize <= targetSize) {
                     targetHighFVC = fvcount;
                     if (targetLowFVC < 0)
                         targetLowFVC = fvcount;
                     if (verbose > 4)
                         Utils.log.info("better pop-size at fvc="+fvcount+
                                          " by "+pct(bestPopSize-currentSize,
                                                     bestPopSize));
                 }
                 bestPopSize = currentSize;
                 bestPopFVC = fvcount;
             }
         }
         if (targetLowFVC < 0) {
             if (verbose > 1) {
                 // Complete loss.
                 if (verbose > 1)
                     Utils.log.info("no good pop-size; best was "+
                                      bestPopSize+" at "+bestPopFVC+
                                      " worse by "+
                                      pct(bestPopSize-bestByteSize,
                                          bestByteSize));
             }
             return;
         }
         if (verbose > 1)
             Utils.log.info("initial best pop-size at fvc="+bestPopFVC+
                              " in ["+targetLowFVC+".."+targetHighFVC+"]"+
                              " by "+pct(bestByteSize-bestPopSize,
                                         bestByteSize));
         int oldZipSize = bestZipSize;
         // Now close onto a specific coding, testing more rigorously
         // with the zipSize metric.
         // Questions to decide:
         //   1. How many favored values?
         //   2. What token coding (TC)?
         //   3. Sort favored values by value within length brackets?
         //   4. What favored coding?
         //   5. What unfavored coding?
         // Steps 1/2/3 are interdependent, and may be iterated.
         // Steps 4 and 5 may be decided independently afterward.
         int[] LValuesCoded = PopulationCoding.LValuesCoded;
         List<Coding> bestFits = new ArrayList<>();
         List<Coding> fullFits = new ArrayList<>();
         List<Coding> longFits = new ArrayList<>();
         final int PACK_TO_MAX_S = 1;
         if (bestPopFVC <= 255) {
             bestFits.add(BandStructure.BYTE1);
         } else {
             int bestB = Coding.B_MAX;
             boolean doFullAlso = (effort > POP_EFFORT);
             if (doFullAlso)
                 fullFits.add(BandStructure.BYTE1.setS(PACK_TO_MAX_S));
             for (int i = LValuesCoded.length-1; i >= 1; i--) {
                 int L = LValuesCoded[i];
                 Coding c0 = PopulationCoding.fitTokenCoding(targetLowFVC,  L);
                 Coding c1 = PopulationCoding.fitTokenCoding(bestPopFVC,    L);
                 Coding c3 = PopulationCoding.fitTokenCoding(targetHighFVC, L);
                 if (c1 != null) {
                     if (!bestFits.contains(c1))
                         bestFits.add(c1);
                     if (bestB > c1.B())
                         bestB = c1.B();
                 }
                 if (doFullAlso) {
                     if (c3 == null)  c3 = c1;
                     for (int B = c0.B(); B <= c3.B(); B++) {
                         if (B == c1.B())  continue;
                         if (B == 1)  continue;
                         Coding c2 = c3.setB(B).setS(PACK_TO_MAX_S);
                         if (!fullFits.contains(c2))
                             fullFits.add(c2);
                     }
                 }
             }
             // interleave all B greater than bestB with best and full fits
             for (Iterator<Coding> i = bestFits.iterator(); i.hasNext(); ) {
                 Coding c = i.next();
                 if (c.B() > bestB) {
                     i.remove();
                     longFits.add(0, c);
                 }
             }
         }
         List<Coding> allFits = new ArrayList<>();
         for (Iterator<Coding> i = bestFits.iterator(),
                       j = fullFits.iterator(),
                       k = longFits.iterator();
              i.hasNext() || j.hasNext() || k.hasNext(); ) {
             if (i.hasNext())  allFits.add(i.next());
             if (j.hasNext())  allFits.add(j.next());
             if (k.hasNext())  allFits.add(k.next());
         }
         bestFits.clear();
         fullFits.clear();
         longFits.clear();
         int maxFits = allFits.size();
         if (effort == POP_EFFORT)
             maxFits = 2;
         else if (maxFits > 4) {
             maxFits -= 4;
             maxFits = (maxFits * (effort-POP_EFFORT)
                        ) / (MAX_EFFORT-POP_EFFORT);
             maxFits += 4;
         }
         if (allFits.size() > maxFits) {
             if (verbose > 4)
                 Utils.log.info("allFits before clip: "+allFits);
             allFits.subList(maxFits, allFits.size()).clear();
         }
         if (verbose > 3)
             Utils.log.info("allFits: "+allFits);
         for (Coding tc : allFits) {
             boolean packToMax = false;
             if (tc.S() == PACK_TO_MAX_S) {
                 // Kludge:  setS(PACK_TO_MAX_S) means packToMax here.
                 packToMax = true;
                 tc = tc.setS(0);
             }
             int fVlen;
             if (!packToMax) {
                 fVlen = bestPopFVC;
                 assert(tc.umax() >= fVlen);
                 assert(tc.B() == 1 || tc.setB(tc.B()-1).umax() < fVlen);
             } else {
                 fVlen = Math.min(tc.umax(), targetHighFVC);
                 if (fVlen < targetLowFVC)
                     continue;
                 if (fVlen == bestPopFVC)
                     continue;  // redundant test
             }
             PopulationCoding pop = new PopulationCoding();
             pop.setHistogram(hist);
             pop.setL(tc.L());
             pop.setFavoredValues(allFavoredValues, fVlen);
             assert(pop.tokenCoding == tc);  // predict correctly
             pop.resortFavoredValues();
             int[] tcsizes =
                 computePopSizePrivate(pop,
                                       favoredCoding, unfavoredCoding);
             noteSizes(pop, tcsizes[BYTE_SIZE], BAND_HEADER+tcsizes[ZIP_SIZE]);
         }
         if (verbose > 3) {
             Utils.log.info("measured best pop, size="+bestByteSize+
                              "/zs="+bestZipSize+
                              " better by "+
                              pct(oldZipSize-bestZipSize, oldZipSize));
             if (bestZipSize < oldZipSize) {
                 Utils.log.info(">>> POP WINS BY "+
                                  (oldZipSize - bestZipSize));
             }
         }
     }
 
     private
     int[] computePopSizePrivate(PopulationCoding pop,
                                 Coding favoredCoding,
                                 Coding unfavoredCoding) {
         if (popHelper == null) {
             popHelper = new CodingChooser(effort, allCodingChoices);
             if (stress != null)
                 popHelper.addStressSeed(stress.nextInt());
             popHelper.topLevel = false;
             popHelper.verbose -= 1;
             popHelper.disablePopCoding = true;
             popHelper.disableRunCoding = this.disableRunCoding;
             if (effort < MID_EFFORT)
                 // No nested run codings.
                 popHelper.disableRunCoding = true;
         }
         int fVlen = pop.fVlen;
         if (verbose > 2) {
             Utils.log.info("computePopSizePrivate fvlen="+fVlen+
                              " tc="+pop.tokenCoding);
             Utils.log.info("{ //BEGIN");
         }
 
         // Find good coding choices for the token and unfavored sequences.
         int[] favoredValues = pop.fValues;
         int[][] vals = pop.encodeValues(values, start, end);
         int[] tokens = vals[0];
         int[] unfavoredValues = vals[1];
         if (verbose > 2)
             Utils.log.info("-- refine on fv["+fVlen+"] fc="+favoredCoding);
         pop.setFavoredCoding(popHelper.choose(favoredValues, 1, 1+fVlen, favoredCoding));
         if (pop.tokenCoding instanceof Coding &&
             (stress == null || stress.nextBoolean())) {
             if (verbose > 2)
                 Utils.log.info("-- refine on tv["+tokens.length+"] tc="+pop.tokenCoding);
             CodingMethod tc = popHelper.choose(tokens, (Coding) pop.tokenCoding);
             if (tc != pop.tokenCoding) {
                 if (verbose > 2)
                     Utils.log.info(">>> refined tc="+tc);
                 pop.setTokenCoding(tc);
             }
         }
         if (unfavoredValues.length == 0)
             pop.setUnfavoredCoding(null);
         else {
             if (verbose > 2)
                 Utils.log.info("-- refine on uv["+unfavoredValues.length+"] uc="+pop.unfavoredCoding);
             pop.setUnfavoredCoding(popHelper.choose(unfavoredValues, unfavoredCoding));
         }
         if (verbose > 3) {
             Utils.log.info("finish computePopSizePrivate fvlen="+fVlen+
                              " fc="+pop.favoredCoding+
                              " tc="+pop.tokenCoding+
                              " uc="+pop.unfavoredCoding);
             //pop.hist.print("pop-hist", null, System.out);
             StringBuilder sb = new StringBuilder();
             sb.append("fv = {");
             for (int i = 1; i <= fVlen; i++) {
                 if ((i % 10) == 0)
                     sb.append('\n');
                 sb.append(" ").append(favoredValues[i]);
             }
             sb.append('\n');
             sb.append("}");
             Utils.log.info(sb.toString());
         }
         if (verbose > 2) {
             Utils.log.info("} //END");
         }
         if (stress != null) {
             return null;  // do not bother with size computation
         }
         int[] sizes;
         try {
             resetData();
             // Write the array of favored values.
             pop.writeSequencesTo(byteSizer, tokens, unfavoredValues);
             sizes = new int[] { getByteSize(), getZipSize() };
         } catch (IOException ee) {
             throw new RuntimeException(ee); // cannot happen
         }
         int[] checkSizes = null;
         assert((checkSizes = computeSizePrivate(pop)) != null);
         assert(checkSizes[BYTE_SIZE] == sizes[BYTE_SIZE])
             : (checkSizes[BYTE_SIZE]+" != "+sizes[BYTE_SIZE]);
         return sizes;
     }
 
     private void tryAdaptiveCoding(Coding plainCoding) {
         int oldZipSize = bestZipSize;
         // Scan the value sequence, determining whether an interesting
         // run occupies too much space.  ("Too much" means, say 5% more
         // than the average integer size of the band as a whole.)
         // Try to find a better coding for those segments.
         int   lstart  = this.start;
         int   lend    = this.end;
         int[] lvalues = this.values;
         int len = lend-lstart;
         if (plainCoding.isDelta()) {
             lvalues = getDeltas(0,0); //%%% not quite right!
             lstart = 0;
             lend = lvalues.length;
         }
         int[] sizes = new int[len+1];
         int fillp = 0;
         int totalSize = 0;
         for (int i = lstart; i < lend; i++) {
             int val = lvalues[i];
             sizes[fillp++] = totalSize;
             int size = plainCoding.getLength(val);
             assert(size < Integer.MAX_VALUE);
             //System.out.println("len "+val+" = "+size);
             totalSize += size;
         }
         sizes[fillp++] = totalSize;
         assert(fillp == sizes.length);
         double avgSize = (double)totalSize / len;
         double sizeFuzz;
         double sizeFuzz2;
         double sizeFuzz3;
         if (effort >= MID_EFFORT) {
             if (effort > MID_EFFORT+1)
                 sizeFuzz = 1.001;
             else
                 sizeFuzz = 1.003;
         } else {
             if (effort > RUN_EFFORT)
                 sizeFuzz = 1.01;
             else
                 sizeFuzz = 1.03;
         }
         // for now:
         sizeFuzz *= sizeFuzz; // double the thresh
         sizeFuzz2 = (sizeFuzz*sizeFuzz);
         sizeFuzz3 = (sizeFuzz*sizeFuzz*sizeFuzz);
         // Find some mesh scales we like.
         double[] dmeshes = new double[1 + (effort-RUN_EFFORT)];
         double logLen = Math.log(len);
         for (int i = 0; i < dmeshes.length; i++) {
             dmeshes[i] = Math.exp(logLen*(i+1)/(dmeshes.length+1));
         }
         int[] meshes = new int[dmeshes.length];
         int mfillp = 0;
         for (int i = 0; i < dmeshes.length; i++) {
             int m = (int)Math.round(dmeshes[i]);
             m = AdaptiveCoding.getNextK(m-1);
             if (m <= 0 || m >= len)  continue;
             if (mfillp > 0 && m == meshes[mfillp-1])  continue;
             meshes[mfillp++] = m;
         }
         meshes = BandStructure.realloc(meshes, mfillp);
         // There's going to be a band header.  Estimate conservatively large.
         final int BAND_HEADER = 4; // op, KB, A, B
         // Threshold values for a "too big" mesh.
         int[]    threshes = new int[meshes.length];
         double[] fuzzes   = new double[meshes.length];
         for (int i = 0; i < meshes.length; i++) {
             int mesh = meshes[i];
             double lfuzz;
             if (mesh < 10)
                 lfuzz = sizeFuzz3;
             else if (mesh < 100)
                 lfuzz = sizeFuzz2;
             else
                 lfuzz = sizeFuzz;
             fuzzes[i] = lfuzz;
             threshes[i] = BAND_HEADER + (int)Math.ceil(mesh * avgSize * lfuzz);
         }
         if (verbose > 1) {
             System.out.print("tryAdaptiveCoding ["+len+"]"+
                              " avgS="+avgSize+" fuzz="+sizeFuzz+
                              " meshes: {");
             for (int i = 0; i < meshes.length; i++) {
                 System.out.print(" " + meshes[i] + "(" + threshes[i] + ")");
             }
             Utils.log.info(" }");
         }
         if (runHelper == null) {
             runHelper = new CodingChooser(effort, allCodingChoices);
             if (stress != null)
                 runHelper.addStressSeed(stress.nextInt());
             runHelper.topLevel = false;
             runHelper.verbose -= 1;
             runHelper.disableRunCoding = true;
             runHelper.disablePopCoding = this.disablePopCoding;
             if (effort < MID_EFFORT)
                 // No nested pop codings.
                 runHelper.disablePopCoding = true;
         }
         for (int i = 0; i < len; i++) {
             i = AdaptiveCoding.getNextK(i-1);
             if (i > len)  i = len;
             for (int j = meshes.length-1; j >= 0; j--) {
                 int mesh   = meshes[j];
                 int thresh = threshes[j];
                 if (i+mesh > len)  continue;
                 int size = sizes[i+mesh] - sizes[i];
                 if (size >= thresh) {
                     // Found a size bulge.
                     int bend  = i+mesh;
                     int bsize = size;
                     double bigSize = avgSize * fuzzes[j];
                     while (bend < len && (bend-i) <= len/2) {
                         int bend0 = bend;
                         int bsize0 = bsize;
                         bend += mesh;
                         bend = i+AdaptiveCoding.getNextK(bend-i-1);
                         if (bend < 0 || bend > len)
                             bend = len;
                         bsize = sizes[bend]-sizes[i];
                         if (bsize < BAND_HEADER + (bend-i) * bigSize) {
                             bsize = bsize0;
                             bend = bend0;
                             break;
                         }
                     }
                     int nexti = bend;
                     if (verbose > 2) {
                         Utils.log.info("bulge at "+i+"["+(bend-i)+"] of "+
                                          pct(bsize - avgSize*(bend-i),
                                              avgSize*(bend-i)));
                         Utils.log.info("{ //BEGIN");
                     }
                     CodingMethod begcm, midcm, endcm;
                     midcm = runHelper.choose(this.values,
                                              this.start+i,
                                              this.start+bend,
                                              plainCoding);
                     if (midcm == plainCoding) {
                         // No use working further.
                         begcm = plainCoding;
                         endcm = plainCoding;
                     } else {
                         begcm = runHelper.choose(this.values,
                                                  this.start,
                                                  this.start+i,
                                                  plainCoding);
                         endcm = runHelper.choose(this.values,
                                                  this.start+bend,
                                                  this.start+len,
                                                  plainCoding);
                     }
                     if (verbose > 2)
                         Utils.log.info("} //END");
                     if (begcm == midcm && i > 0 &&
                         AdaptiveCoding.isCodableLength(bend)) {
                         i = 0;
                     }
                     if (midcm == endcm && bend < len) {
                         bend = len;
                     }
                     if (begcm != plainCoding ||
                         midcm != plainCoding ||
                         endcm != plainCoding) {
                         CodingMethod chain;
                         int hlen = 0;
                         if (bend == len) {
                             chain = midcm;
                         } else {
                             chain = new AdaptiveCoding(bend-i, midcm, endcm);
                             hlen += BAND_HEADER;
                         }
                         if (i > 0) {
                             chain = new AdaptiveCoding(i, begcm, chain);
                             hlen += BAND_HEADER;
                         }
                         int[] chainSize = computeSizePrivate(chain);
                         noteSizes(chain,
                                   chainSize[BYTE_SIZE],
                                   chainSize[ZIP_SIZE]+hlen);
                     }
                     i = nexti;
                     break;
                 }
             }
         }
         if (verbose > 3) {
             if (bestZipSize < oldZipSize) {
                 Utils.log.info(">>> RUN WINS BY "+
                                  (oldZipSize - bestZipSize));
             }
         }
     }
 
     static private
     String pct(double num, double den) {
         return (Math.round((num / den)*10000)/100.0)+"%";
     }
 
     static
     class Sizer extends OutputStream {
         final OutputStream out;  // if non-null, copy output here also
         Sizer(OutputStream out) {
             this.out = out;
         }
         Sizer() {
             this(null);
         }
         private int count;
         public void write(int b) throws IOException {
             count++;
             if (out != null)  out.write(b);
         }
         public void write(byte b[], int off, int len) throws IOException {
             count += len;
             if (out != null)  out.write(b, off, len);
         }
         public void reset() {
             count = 0;
         }
         public int getSize() { return count; }
 
         public String toString() {
             String str = super.toString();
             // If -ea, print out more informative strings!
             assert((str = stringForDebug()) != null);
             return str;
         }
         String stringForDebug() {
             return "<Sizer "+getSize()+">";
         }
     }
 
     private Sizer zipSizer  = new Sizer();
     private Deflater zipDef = new Deflater();
     private DeflaterOutputStream zipOut = new DeflaterOutputStream(zipSizer, zipDef);
     private Sizer byteSizer = new Sizer(zipOut);
     private Sizer byteOnlySizer = new Sizer();
 
     private void resetData() {
         flushData();
         zipDef.reset();
         if (context != null) {
             // Prepend given salt to the test output.
             try {
                 context.writeTo(byteSizer);
             } catch (IOException ee) {
                 throw new RuntimeException(ee); // cannot happen
             }
         }
         zipSizer.reset();
         byteSizer.reset();
     }
     private void flushData() {
         try {
             zipOut.finish();
         } catch (IOException ee) {
             throw new RuntimeException(ee); // cannot happen
         }
     }
     private int getByteSize() {
         return byteSizer.getSize();
     }
     private int getZipSize() {
         flushData();
         return zipSizer.getSize();
     }
 
 
     /// Stress-test helpers.
 
     void addStressSeed(int x) {
         if (stress == null)  return;
         stress.setSeed(x + ((long)stress.nextInt() << 32));
     }
 
     // Pick a random pop-coding.
     private CodingMethod stressPopCoding(CodingMethod coding) {
         assert(stress != null);  // this method is only for testing
         // Don't turn it into a pop coding if it's already something special.
         if (!(coding instanceof Coding))  return coding;
         Coding valueCoding = ((Coding)coding).getValueCoding();
         Histogram hist = getValueHistogram();
         int fVlen = stressLen(hist.getTotalLength());
         if (fVlen == 0)  return coding;
         List<Integer> popvals = new ArrayList<>();
         if (stress.nextBoolean()) {
             // Build the population from the value list.
             Set<Integer> popset = new HashSet<>();
             for (int i = start; i < end; i++) {
                 if (popset.add(values[i]))  popvals.add(values[i]);
             }
         } else {
             int[][] matrix = hist.getMatrix();
             for (int mrow = 0; mrow < matrix.length; mrow++) {
                 int[] row = matrix[mrow];
                 for (int mcol = 1; mcol < row.length; mcol++) {
                     popvals.add(row[mcol]);
                 }
             }
         }
         int reorder = stress.nextInt();
         if ((reorder & 7) <= 2) {
             // Lose the order.
             Collections.shuffle(popvals, stress);
         } else {
             // Keep the order, mostly.
             if (((reorder >>>= 3) & 7) <= 2)  Collections.sort(popvals);
             if (((reorder >>>= 3) & 7) <= 2)  Collections.reverse(popvals);
             if (((reorder >>>= 3) & 7) <= 2)  Collections.rotate(popvals, stressLen(popvals.size()));
         }
         if (popvals.size() > fVlen) {
             // Cut the list down.
             if (((reorder >>>= 3) & 7) <= 2) {
                 // Cut at end.
                 popvals.subList(fVlen,   popvals.size()).clear();
             } else {
                 // Cut at start.
                 popvals.subList(0, popvals.size()-fVlen).clear();
             }
         }
         fVlen = popvals.size();
         int[] fvals = new int[1+fVlen];
         for (int i = 0; i < fVlen; i++) {
             fvals[1+i] = (popvals.get(i)).intValue();
         }
         PopulationCoding pop = new PopulationCoding();
         pop.setFavoredValues(fvals, fVlen);
         int[] lvals = PopulationCoding.LValuesCoded;
         for (int i = 0; i < lvals.length / 2; i++) {
             int popl = lvals[stress.nextInt(lvals.length)];
             if (popl < 0)  continue;
             if (PopulationCoding.fitTokenCoding(fVlen, popl) != null) {
                 pop.setL(popl);
                 break;
             }
         }
         if (pop.tokenCoding == null) {
             int lmin = fvals[1], lmax = lmin;
             for (int i = 2; i <= fVlen; i++) {
                 int val = fvals[i];
                 if (lmin > val)  lmin = val;
                 if (lmax < val)  lmax = val;
             }
             pop.tokenCoding = stressCoding(lmin, lmax);
         }
 
         computePopSizePrivate(pop, valueCoding, valueCoding);
         return pop;
     }
 
     // Pick a random adaptive coding.
     private CodingMethod stressAdaptiveCoding(CodingMethod coding) {
         assert(stress != null);  // this method is only for testing
         // Don't turn it into a run coding if it's already something special.
         if (!(coding instanceof Coding))  return coding;
         Coding plainCoding = (Coding)coding;
         int len = end-start;
         if (len < 2)  return coding;
         // Decide how many spans we'll create.
         int spanlen = stressLen(len-1)+1;
         if (spanlen == len)  return coding;
         try {
             assert(!disableRunCoding);
             disableRunCoding = true;  // temporary, while I decide spans
             int[] allValues = values.clone();
             CodingMethod result = null;
             int scan  = this.end;
             int lstart = this.start;
             for (int split; scan > lstart; scan = split) {
                 int thisspan;
                 int rand = (scan - lstart < 100)? -1: stress.nextInt();
                 if ((rand & 7) != 0) {
                     thisspan = (spanlen==1? spanlen: stressLen(spanlen-1)+1);
                 } else {
                     // Every so often generate a value based on KX/KB format.
                     int KX = (rand >>>= 3) & AdaptiveCoding.KX_MAX;
                     int KB = (rand >>>= 3) & AdaptiveCoding.KB_MAX;
                     for (;;) {
                         thisspan = AdaptiveCoding.decodeK(KX, KB);
                         if (thisspan <= scan - lstart)  break;
                         // Try smaller and smaller codings:
                         if (KB != AdaptiveCoding.KB_DEFAULT)
                             KB = AdaptiveCoding.KB_DEFAULT;
                         else
                             KX -= 1;
                     }
                     //System.out.println("KX="+KX+" KB="+KB+" K="+thisspan);
                     assert(AdaptiveCoding.isCodableLength(thisspan));
                 }
                 if (thisspan > scan - lstart)  thisspan = scan - lstart;
                 while (!AdaptiveCoding.isCodableLength(thisspan)) {
                     --thisspan;
                 }
                 split = scan - thisspan;
                 assert(split < scan);
                 assert(split >= lstart);
                 // Choose a coding for the span [split..scan).
                 CodingMethod sc = choose(allValues, split, scan, plainCoding);
                 if (result == null) {
                     result = sc;  // the caboose
                 } else {
                     result = new AdaptiveCoding(scan-split, sc, result);
                 }
             }
             return result;
         } finally {
             disableRunCoding = false; // return to normal value
         }
     }
 
     // Return a random value in [0..len], gently biased toward extremes.
     private Coding stressCoding(int min, int max) {
         assert(stress != null);  // this method is only for testing
         for (int i = 0; i < 100; i++) {
             Coding c = Coding.of(stress.nextInt(Coding.B_MAX)+1,
                                  stress.nextInt(Coding.H_MAX)+1,
                                  stress.nextInt(Coding.S_MAX+1));
             if (c.B() == 1)  c = c.setH(256);
             if (c.H() == 256 && c.B() >= 5)  c = c.setB(4);
             if (stress.nextBoolean()) {
                 Coding dc = c.setD(1);
                 if (dc.canRepresent(min, max))  return dc;
             }
             if (c.canRepresent(min, max))  return c;
         }
         return BandStructure.UNSIGNED5;
     }
 
     // Return a random value in [0..len], gently biased toward extremes.
     private int stressLen(int len) {
         assert(stress != null);  // this method is only for testing
         assert(len >= 0);
         int rand = stress.nextInt(100);
         if (rand < 20)
             return Math.min(len/5, rand);
         else if (rand < 40)
             return len;
         else
             return stress.nextInt(len);
     }
 
     // For debug only.
 /*
     public static
     int[] readValuesFrom(InputStream instr) {
         return readValuesFrom(new InputStreamReader(instr));
     }
     public static
     int[] readValuesFrom(Reader inrdr) {
         inrdr = new BufferedReader(inrdr);
         final StreamTokenizer in = new StreamTokenizer(inrdr);
         final int TT_NOTHING = -99;
         in.commentChar('#');
         return readValuesFrom(new Iterator() {
             int token = TT_NOTHING;
             private int getToken() {
                 if (token == TT_NOTHING) {
                     try {
                         token = in.nextToken();
                         assert(token != TT_NOTHING);
                     } catch (IOException ee) {
                         throw new RuntimeException(ee);
                     }
                 }
                 return token;
             }
             public boolean hasNext() {
                 return getToken() != StreamTokenizer.TT_EOF;
             }
             public Object next() {
                 int ntok = getToken();
                 token = TT_NOTHING;
                 switch (ntok) {
                 case StreamTokenizer.TT_EOF:
                     throw new NoSuchElementException();
                 case StreamTokenizer.TT_NUMBER:
                     return Integer.valueOf((int) in.nval);
                 default:
                     assert(false);
                     return null;
                 }
             }
             public void remove() {
                 throw new UnsupportedOperationException();
             }
         });
     }
     public static
     int[] readValuesFrom(Iterator iter) {
         return readValuesFrom(iter, 0);
     }
     public static
     int[] readValuesFrom(Iterator iter, int initSize) {
         int[] na = new int[Math.max(10, initSize)];
         int np = 0;
         while (iter.hasNext()) {
             Integer val = (Integer) iter.next();
             if (np == na.length) {
                 na = BandStructure.realloc(na);
             }
             na[np++] = val.intValue();
         }
         if (np != na.length) {
             na = BandStructure.realloc(na, np);
         }
         return na;
     }
 
     public static
     void main(String[] av) throws IOException {
         int effort = MID_EFFORT;
         int ap = 0;
         if (ap < av.length && av[ap].equals("-e")) {
             ap++;
             effort = Integer.parseInt(av[ap++]);
         }
         int verbose = 1;
         if (ap < av.length && av[ap].equals("-v")) {
             ap++;
             verbose = Integer.parseInt(av[ap++]);
         }
         Coding[] bcs = BandStructure.getBasicCodings();
         CodingChooser cc = new CodingChooser(effort, bcs);
         if (ap < av.length && av[ap].equals("-p")) {
             ap++;
             cc.optUsePopulationCoding = false;
         }
         if (ap < av.length && av[ap].equals("-a")) {
             ap++;
             cc.optUseAdaptiveCoding = false;
         }
         cc.verbose = verbose;
         int[] values = readValuesFrom(System.in);
         int[] sizes = {0,0};
         CodingMethod cm = cc.choose(values, BandStructure.UNSIGNED5, sizes);
         System.out.println("size: "+sizes[BYTE_SIZE]+"/zs="+sizes[ZIP_SIZE]);
         System.out.println(cm);
     }
 //*/
 
 }